// 版权归Go作者所有。版权所有。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

// 此文件实现标识符和类型表达式的类型检查。

package types

import (
	"fmt"
	"go/ast"
	"go/constant"
	"go/internal/typeparams"
	"go/token"
	"sort"
	"strconv"
	"strings"
)

// ident type检查标识符e并用值或类型e初始化x。
// 如果发生错误，x.mode将设置为无效。
// 有关def的含义，请参阅下面的Checker.definedType。
// 如果设置了wantType，则标识符e应表示类型。
// 
func (check *Checker) ident(x *operand, e *ast.Ident, def *Named, wantType bool) {
	x.mode = invalid
	x.expr = e

	// 请注意，此处不能使用check.lookup，因为返回的作用域
	// 可能与obj.Parent（）不同。另请参见Scope.LookupParent文档。
	scope, obj := check.scope.LookupParent(e.Name, check.pos)
	if obj == nil {
		if e.Name == "_" {
			check.errorf(e, _InvalidBlank, "cannot use _ as value or type")
		} else {
			check.errorf(e, _UndeclaredName, "undeclared name: %s", e.Name)
		}
		return
	}
	check.recordUse(e, obj)

	// 检查对象的类型。
	// 如果对象还没有类型，则只调用Checker.objDecl 
	// （在这种情况下，我们必须实际确定它），或者对象是
	// 类型名，并且我们还需要类型（在这种情况下，我们可能会检测到
	// 需要报告的循环）。否则，我们可以跳过
	// 调用并避免可能的循环错误，以支持此函数的调用方
	// 将发出的更具信息性的“非类型/值”错误（请参见问题#25790）。
	typ := obj.Type()
	if _, gotType := obj.(*TypeName); typ == nil || gotType && wantType {
		check.objDecl(obj, def)
		typ = obj.Type() // 类型必须由Checker分配。objDecl 
	}
	assert(typ != nil)

	// 该对象可能已被点导入。
	// 如果是，请将相应的包装标记为已使用。
	// （此代码仅用于dot导入。没有它们，
	// 我们只需标记变量，请参见下面的*Var案例）。
	if pkgName := check.dotImportMap[dotImportKey{scope, obj}]; pkgName != nil {
		pkgName.used = true
	}

	switch obj := obj.(type) {
	case *PkgName:
		check.errorf(e, _InvalidPkgUse, "use of package %s not in selector", obj.name)
		return

	case *Const:
		check.addDeclDep(obj)
		if typ == Typ[Invalid] {
			return
		}
		if obj == universeIota {
			if check.iota == nil {
				check.errorf(e, _InvalidIota, "cannot use iota outside constant declaration")
				return
			}
			x.val = check.iota
		} else {
			x.val = obj.val
		}
		assert(x.val != nil)
		x.mode = constant_

	case *TypeName:
		x.mode = typexpr

	case *Var:
		// 标记非局部变量是可以的，但是忽略其他包中的变量
		// 以避免与
		// 点导入变量的潜在竞争条件。
		if obj.pkg == check.pkg {
			obj.used = true
		}
		check.addDeclDep(obj)
		if typ == Typ[Invalid] {
			return
		}
		x.mode = variable

	case *Func:
		check.addDeclDep(obj)
		x.mode = value

	case *Builtin:
		x.id = obj.id
		x.mode = builtin

	case *Nil:
		x.mode = value

	default:
		unreachable()
	}

	x.typ = typ
}

// typ type检查类型表达式e并返回其类型，或typ[Invalid]。
// 该类型不能是（未实例化的）泛型类型。
func (check *Checker) typ(e ast.Expr) Type {
	return check.definedType(e, nil)
}

// varType type检查类型表达式e并返回其类型，或类型[Invalid]。
// 该类型不能是（未实例化的）泛型类型，并且必须是普通
// （请参见普通类型）。
func (check *Checker) varType(e ast.Expr) Type {
	typ := check.definedType(e, nil)
	check.ordinaryType(e, typ)
	return typ
}

// 如果typ是包含
// 类型列表或是（或嵌入）预声明类型的接口类型，则ordinaryType报告错误。ABCFDG 
func (check *Checker) ordinaryType(pos positioner, typ Type) {
	// 类型检查结束。这是正确的位置吗？
	check.later(func() {
		if t := asInterface(typ); t != nil {
			if t.allTypes != nil {
				check.softErrorf(pos, _Todo, "interface contains type constraints (%s)", t.allTypes)
				return
			}
			if t._IsComparable() {
				check.softErrorf(pos, _Todo, "interface is (or embeds) comparable")
			}
		}
	})
}

// anyType type检查类型表达式e并返回其类型，或类型[Invalid]。
// 类型可以是泛型的，也可以是实例化的。
func (check *Checker) anyType(e ast.Expr) Type {
	typ := check.typInternal(e, nil)
	assert(isTyped(typ))
	check.recordTypeAndValue(e, typexpr, typ, nil)
	return typ
}

// definedType与typ类似，但也接受类型名def。
// 如果定义！=nil，e是定义的类型def的类型规范，在类型声明中声明为
// 并且def.underground将在
// 检查e的任何组件之前设置为e的类型。
// 
func (check *Checker) definedType(e ast.Expr, def *Named) Type {
	typ := check.typInternal(e, def)
	assert(isTyped(typ))
	if isGeneric(typ) {
		check.errorf(e, _Todo, "cannot use generic type %s without instantiation", typ)
		typ = Typ[Invalid]
	}
	check.recordTypeAndValue(e, typexpr, typ, nil)
	return typ
}

// genericType类似于typ，但类型必须是（未实例化的）泛型类型。
func (check *Checker) genericType(e ast.Expr, reportErr bool) Type {
	typ := check.typInternal(e, nil)
	assert(isTyped(typ))
	if typ != Typ[Invalid] && !isGeneric(typ) {
		if reportErr {
			check.errorf(e, _Todo, "%s is not a generic type", typ)
		}
		typ = Typ[Invalid]
	}
	// TODO（gri）下面的正确呼叫是什么？
	check.recordTypeAndValue(e, typexpr, typ, nil)
	return typ
}

// isubst返回一个x，其中标识符根据替换映射smap进行替换。
// isubst仅正确处理（有效）方法接收器类型表达式的大小写。
func isubst(x ast.Expr, smap map[*ast.Ident]*ast.Ident) ast.Expr {
	switch n := x.(type) {
	case *ast.Ident:
		if alt := smap[n]; alt != nil {
			return alt
		}
	case *ast.StarExpr:
		X := isubst(n.X, smap)
		if X != n.X {
			new := *n
			new.X = X
			return &new
		}
	case *ast.IndexExpr:
		elems := typeparams.UnpackExpr(n.Index)
		var newElems []ast.Expr
		for i, elem := range elems {
			new := isubst(elem, smap)
			if new != elem {
				if newElems == nil {
					newElems = make([]ast.Expr, len(elems))
					copy(newElems, elems)
				}
				newElems[i] = new
			}
		}
		if newElems != nil {
			index := typeparams.PackExpr(newElems)
			new := *n
			new.Index = index
			return &new
		}
	case *ast.ParenExpr:
		return isubst(n.X, smap) // 不需要保留括号
	default:
		// 其他接收器类型表达式无效。
		// 忽略这里的那些是可以的，因为它们将在其他地方被检查。
	}
	return x
}

// funcType类型检查函数或方法类型。
func (check *Checker) funcType(sig *Signature, recvPar *ast.FieldList, ftyp *ast.FuncType) {
	check.openScope(ftyp, "function")
	check.scope.isFunc = true
	check.recordScope(ftyp, check.scope)
	sig.scope = check.scope
	defer check.closeScope()

	var recvTyp ast.Expr // 重写的接收器类型；如果有效！=nil 
	if recvPar != nil && len(recvPar.List) > 0 {
		// 收集通用接收器类型参数，如果任何
		// -接收器类型参数与任何其他类型参数类似，但它是隐式声明的
		// -接收器规范充当其类型参数的本地声明，可能为空
		_, rname, rparams := check.unpackRecv(recvPar.List[0].Type, true)
		if len(rparams) > 0 {
			// 未声明空标识符，且对实例化的
			// 参数化接收方类型表达式的常规类型检查在接收方的Checker.collectParams中失败。
			// 标识空白类型参数，并用名为
			// “n_”（其中n是参数索引）的唯一新标识符替换每个参数，该标识符不能与任何用户定义的
			// 名称冲突。
			var smap map[*ast.Ident]*ast.Ident // 从“u”到“n_u”标识符的替换映射
			for i, p := range rparams {
				if p.Name == "_" {
					new := *p
					new.Name = fmt.Sprintf("%d_", i)
					rparams[i] = &new // 使用n_u2;标识符而不是2;以便可以查找
					if smap == nil {
						smap = make(map[*ast.Ident]*ast.Ident)
					}
					smap[p] = &new
				}
			}
			if smap != nil {
				// 找到空白标识符=>使用重写的接收器类型
				recvTyp = isubst(recvPar.List[0].Type, smap)
			}
			sig.rparams = check.declareTypeParams(nil, rparams)
			// 确定接收器类型以获取其类型参数
			// 并且相应的类型参数边界
			var recvTParams []*TypeName
			if rname != nil {
				// recv应为命名类型（否则其他地方会报告错误）
				// 另外：不要通过genericType报告错误，因为当我们键入检查签名时，会再次报告错误。
				// TODO（gri）也许应该将接收器标记为无效？
				if recv := asNamed(check.genericType(rname, false)); recv != nil {
					recvTParams = recv.tparams
				}
			}
			// 提供类型参数边界
			// -仅当我们有正确的编号（否则其他地方会报告错误）
			if len(sig.rparams) == len(recvTParams) {
				// 我们有一个*类型名列表，但我们需要一个类型列表。
				list := make([]Type, len(sig.rparams))
				for i, t := range sig.rparams {
					list[i] = t.typ
				}
				smap := makeSubstMap(recvTParams, list)
				for i, tname := range sig.rparams {
					bound := recvTParams[i].typ.(*_TypeParam).bound
					// 绑定（可能）在
					// 接收器类型声明的上下文中参数化。将参数替换为
					// 当前上下文。
					// TODO（gri）我们现在应该假设边界始终存在吗？
					// （无边界==空接口）
					if bound != nil {
						bound = check.subst(tname.pos, bound, smap)
						tname.typ.(*_TypeParam).bound = bound
					}
				}
			}
		}
	}

	if tparams := typeparams.Get(ftyp); tparams != nil {
		sig.tparams = check.collectTypeParams(tparams)
		// 始终使用类型检查方法类型参数，但抱怨不允许使用它们。
		// （在类型检查接口方法签名时需要单独检查，因为
		// 它们没有接收器规范。）
		if recvPar != nil {
			check.errorf(tparams, _Todo, "methods cannot have type parameters")
		}
	}

	// 值（非类型）参数的作用域从函数体开始。为其
	// 声明使用一个临时作用域，然后将该作用域挤压到父作用域中（并报告当时
	// 的任何重新声明）。
	scope := NewScope(check.scope, token.NoPos, token.NoPos, "function body (temp. scope)")
	recvList, _ := check.collectParams(scope, recvPar, recvTyp, false) // 如果存在任何
	params, variadic := check.collectParams(scope, ftyp.Params, nil, true)
	results, _ := check.collectParams(scope, ftyp.Results, nil, false)
	scope.squash(func(obj, alt Object) {
		check.errorf(obj, _DuplicateDecl, "%s redeclared in this block", obj.Name())
		check.reportAltDecl(alt)
	})

	if recvPar != nil {
		// recv参数列表，请使用重写的接收器类型（可能为空）
		// 规范：“通过
		// 方法名称前面的额外参数节指定接收器。该参数节必须声明单个参数，即接收器。”
		var recv *Var
		switch len(recvList) {
		case 0:
			// 解析程序报告的错误
			recv = NewParam(0, nil, "", Typ[Invalid]) // 忽略
		default:
			// 多个接收器
			check.error(recvList[len(recvList)-1], _BadRecv, "method must have exactly one receiver")
			fallthrough // 继续使用第一个接收器
		case 1:
			recv = recvList[0]
		}

		// TODO（gri）我们应该将rtyp扩展延迟到实际需要接收器的时候；因此这里的所有检查都应该延迟到以后。
		rtyp, _ := deref(recv.typ)
		rtyp = expand(rtyp)

		// 规范：“接收器类型必须是T或*T形式，其中T是类型名。”
		// （忽略无效类型-之前报告过错误）
		if t := rtyp; t != Typ[Invalid] {
			var err string
			if T := asNamed(t); T != nil {
				// spec:“用T表示的类型称为接收器基类型；它不能是指针或接口类型，并且必须在与方法相同的包
				// 中声明。”
				if T.obj.pkg != check.pkg {
					err = "type not defined in this package"
				} else {
					switch u := optype(T).(type) {
					case *Basic:
						// 不安全。指针被视为常规指针
						if u.kind == UnsafePointer {
							err = "unsafe.Pointer"
						}
					case *Pointer, *Interface:
						err = "pointer or interface type"
					}
				}
			} else {
				err = "basic or unnamed type"
			}
			if err != "" {
				check.errorf(recv, _InvalidRecv, "invalid receiver %s (%s)", recv.typ, err)
				// 确定继续
			}
		}
		sig.recv = recv
	}

	sig.params = NewTuple(params...)
	sig.results = NewTuple(results...)
	sig.variadic = variadic
}

// goTypeName返回typ的Go类型名称，
// 删除所有出现的“类型”从该名称开始。
func goTypeName(typ Type) string {
	return strings.ReplaceAll(fmt.Sprintf("%T", typ), "types.", "")
}

// typeinternal drives类型检查。
// 只能由definedType或genericType调用。
// 
func (check *Checker) typInternal(e0 ast.Expr, def *Named) (T Type) {
	if trace {
		check.trace(e0.Pos(), "type %s", e0)
		check.indent++
		defer func() {
			check.indent--
			var under Type
			if T != nil {
				// 在（）下调用可能会导致无休止的实例化。
				// 测试用例：type T[P any]*T[P]
				// TODO（gri）调查这是否是一个错误或是预期的
				// （另请参见Checker.实例化中的类似注释）。
				under = T.Underlying()
			}
			if T == under {
				check.trace(e0.Pos(), "=> %s // /%s“，T，goTypeName（T））
			} else {
				check.trace(e0.Pos(), "=> %s (under = %s) // /%s”，T，under，goTypeName（T））
			}
		}()
	}

	switch e := e0.(type) {
	case *ast.BadExpr:
		// 忽略-在

	case *ast.Ident:
		var x operand
		check.ident(&x, e, def, true)

		switch x.mode {
		case typexpr:
			typ := x.typ
			def.setUnderlying(typ)
			return typ
		case invalid:
			// 之前报告的错误忽略-在
		case novalue:
			check.errorf(&x, _NotAType, "%s used as type", &x)
		default:
			check.errorf(&x, _NotAType, "%s is not a type", &x)
		}

	case *ast.SelectorExpr:
		var x operand
		check.selector(&x, e)

		switch x.mode {
		case typexpr:
			typ := x.typ
			def.setUnderlying(typ)
			return typ
		case invalid:
			// 忽略-在
		case novalue:
			check.errorf(&x, _NotAType, "%s used as type", &x)
		default:
			check.errorf(&x, _NotAType, "%s is not a type", &x)
		}

	case *ast.IndexExpr:
		if typeparams.Enabled {
			exprs := typeparams.UnpackExpr(e.Index)
			return check.instantiatedType(e.X, exprs, def)
		}
		check.errorf(e0, _NotAType, "%s is not a type", e0)
		check.use(e.X)

	case *ast.ParenExpr:
		// 之前报告的错误必须实例化泛型类型才能以任何形式使用。
		// 因此，泛型类型不能用括号括起来。
		return check.definedType(e.X, def)

	case *ast.ArrayType:
		if e.Len != nil {
			typ := new(Array)
			def.setUnderlying(typ)
			typ.len = check.arrayLength(e.Len)
			typ.elem = check.varType(e.Elt)
			return typ
		}

		typ := new(Slice)
		def.setUnderlying(typ)
		typ.elem = check.varType(e.Elt)
		return typ

	case *ast.Ellipsis:
		// 点在合法的位置被显式处理
		// （数组复合文字和参数列表）
		check.error(e, _InvalidDotDotDot, "invalid use of '...'")
		check.use(e.Elt)

	case *ast.StructType:
		typ := new(Struct)
		def.setUnderlying(typ)
		check.structType(typ, e)
		return typ

	case *ast.StarExpr:
		typ := new(Pointer)
		def.setUnderlying(typ)
		typ.base = check.varType(e.X)
		return typ

	case *ast.FuncType:
		typ := new(Signature)
		def.setUnderlying(typ)
		check.funcType(typ, nil, e)
		return typ

	case *ast.InterfaceType:
		typ := new(Interface)
		def.setUnderlying(typ)
		if def != nil {
			typ.obj = def.obj
		}
		check.interfaceType(typ, e, def)
		return typ

	case *ast.MapType:
		typ := new(Map)
		def.setUnderlying(typ)

		typ.key = check.varType(e.Key)
		typ.elem = check.varType(e.Value)

		// 规范：“比较运算符==和！=对于键类型的操作数，必须完全定义
		// ；因此，密钥类型不能是
		// 函数、映射或切片。“
		// 
		// 延迟此检查，因为它需要完全设置类型；
		// 在任何情况下都可以安全地继续（was问题6667）.
		check.later(func() {
			if !Comparable(typ.key) {
				var why string
				if asTypeParam(typ.key) != nil {
					why = " (missing comparable constraint)"
				}
				check.errorf(e.Key, _IncomparableMapKey, "incomparable map key type %s%s", typ.key, why)
			}
		})

		return typ

	case *ast.ChanType:
		typ := new(Chan)
		def.setUnderlying(typ)

		dir := SendRecv
		switch e.Dir {
		case ast.SEND | ast.RECV:
			// 无需执行
		case ast.SEND:
			dir = SendOnly
		case ast.RECV:
			dir = RecvOnly
		default:
			check.invalidAST(e, "unknown channel direction %d", e.Dir)
			// 确定继续
		}

		typ.dir = dir
		typ.elem = check.varType(e.Value)
		return typ

	default:
		check.errorf(e0, _NotAType, "%s is not a type", e0)
	}

	typ := Typ[Invalid]
	def.setUnderlying(typ)
	return typ
}

// typeOrNil type检查类型表达式（或nil值）e 
// 并返回类型e或nil。如果e是一个类型，则它必须
// 不是（未实例化的）泛型类型。
// 如果e既不是类型也不是零，则typeOrNil返回Typ[Invalid]。
// TODO（gri）我们是否也应该禁止非var类型？
func (check *Checker) typeOrNil(e ast.Expr) Type {
	var x operand
	check.rawExpr(&x, e, nil)
	switch x.mode {
	case invalid:
		// 忽略-在
	case novalue:
		check.errorf(&x, _NotAType, "%s used as type", &x)
	case typexpr:
		check.instantiatedOperand(&x)
		return x.typ
	case value:
		if x.isNil() {
			return nil
		}
		fallthrough
	default:
		check.errorf(&x, _NotAType, "%s is not a type", &x)
	}
	return Typ[Invalid]
}

func (check *Checker) instantiatedType(x ast.Expr, targs []ast.Expr, def *Named) Type {
	b := check.genericType(x, true) // TODO（gri）之前报告的错误？关于周期呢
	if b == Typ[Invalid] {
		return b // 已报告错误
	}
	base := asNamed(b)
	if base == nil {
		unreachable() // 应已被泛型
	}

	// 创建新类型实例而不是实例化类型
	// TODO（gri）在实例化类型时应在此处执行参数号检查而不是
	// 吗？
	typ := new(instance)
	def.setUnderlying(typ)

	typ.check = check
	typ.pos = x.Pos()
	typ.base = base

	// 评估参数（始终）
	typ.targs = check.typeList(targs)
	if typ.targs == nil {
		def.setUnderlying(Typ[Invalid]) // 避免由于延迟实例化而导致的后续错误
		return Typ[Invalid]
	}

	// 确定参数位置（用于错误报告）
	typ.poslist = make([]token.Pos, len(targs))
	for i, arg := range targs {
		typ.poslist[i] = arg.Pos()
	}

	// 确保我们检查实例化至少工作一次
	// 并且得到的类型是有效的
	check.later(func() {
		t := typ.expand()
		check.validType(t, nil)
	})

	return typ
}

// arrayLength类型检查数组长度表达式e 
// 并返回常量长度>=0或值<0 
// 以指示错误（因此长度未知）。
func (check *Checker) arrayLength(e ast.Expr) int64 {
	var x operand
	check.expr(&x, e)
	if x.mode != constant_ {
		if x.mode != invalid {
			check.errorf(&x, _InvalidArrayLen, "array length %s must be constant", &x)
		}
		return -1
	}
	if isUntyped(x.typ) || isInteger(x.typ) {
		if val := constant.ToInt(x.val); val.Kind() == constant.Int {
			if representableConst(val, check, Typ[Int], nil) {
				if n, ok := constant.Int64Val(val); ok && n >= 0 {
					return n
				}
				check.errorf(&x, _InvalidArrayLen, "invalid array length %s", &x)
				return -1
			}
		}
	}
	check.errorf(&x, _InvalidArrayLen, "array length %s must be integer", &x)
	return -1
}

// typeList提供与传入表达式列表相对应的类型列表。
// 如果发生错误，结果为零，但所有列表元素都进行了类型检查。
func (check *Checker) typeList(list []ast.Expr) []Type {
	res := make([]Type, len(list)) // res！=nil，即使len（list）==0 
	for i, x := range list {
		t := check.varType(x)
		if t == Typ[Invalid] {
			res = nil
		}
		if res != nil {
			res[i] = t
		}
	}
	return res
}

// collectParams在作用域中声明list的参数并返回相应的
// 变量list。如果type0！=nil，则使用它代替list中的第一个类型。
func (check *Checker) collectParams(scope *Scope, list *ast.FieldList, type0 ast.Expr, variadicOk bool) (params []*Var, variadic bool) {
	if list == nil {
		return
	}

	var named, anonymous bool
	for i, field := range list.List {
		ftype := field.Type
		if i == 0 && type0 != nil {
			ftype = type0
		}
		if t, _ := ftype.(*ast.Ellipsis); t != nil {
			ftype = t.Elt
			if variadicOk && i == len(list.List)-1 && len(field.Names) <= 1 {
				variadic = true
			} else {
				check.softErrorf(t, _MisplacedDotDotDot, "can only use ... with final parameter in list")
				// 忽略…并继续
			}
		}
		typ := check.varType(ftype)
		// 解析器确保f.Tag为零，而我们不使用
		// 注意构造的AST是否包含非零标记。
		if len(field.Names) > 0 {
			// 命名参数
			for _, name := range field.Names {
				if name.Name == "" {
					check.invalidAST(name, "anonymous parameter")
					// 确定继续
				}
				par := NewParam(name.Pos(), check.pkg, name.Name, typ)
				check.declare(scope, name, par, scope.pos)
				params = append(params, par)
			}
			named = true
		} else {
			// 匿名参数
			par := NewParam(ftype.Pos(), check.pkg, "", typ)
			check.recordImplicit(field, par)
			params = append(params, par)
			anonymous = true
		}
	}

	if named && anonymous {
		check.invalidAST(list, "list contains both named and anonymous parameters")
		// 确定继续
	}

	// 对于变量函数，将最后一个参数的类型从T更改为[]T.
	// 因为我们选择了T而不是…T，所以我们还需要追溯
	// 为…T.
	if variadic {
		last := params[len(params)-1]
		last.typ = &Slice{elem: last.typ}
		check.recordTypeAndValue(list.List[len(list.List)-1].Type, typexpr, last.typ, nil)
	}

	return
}

func (check *Checker) declareInSet(oset *objset, pos token.Pos, obj Object) bool {
	if alt := oset.insert(obj); alt != nil {
		check.errorf(atPos(pos), _DuplicateDecl, "%s redeclared", obj.Name())
		check.reportAltDecl(alt)
		return false
	}
	return true
}

func (check *Checker) interfaceType(ityp *Interface, iface *ast.InterfaceType, def *Named) {
	var tlist *ast.Ident // “type”类型列表声明中第一个条目的名称
	var types []ast.Expr
	for _, f := range iface.Methods.List {
		if len(f.Names) > 0 {
			// 我们有一个名为f.Names[0]的方法，或者一个类型列表的类型
			// 类型（name.name==“type”).
			// （解析器确保只有一个方法
			// ，我们不关心构造的AST是否有更多方法。）
			name := f.Names[0]
			if name.Name == "_" {
				check.errorf(name, _BlankIfaceMethod, "invalid method name _")
				continue // 忽略
			}

			if name.Name == "type" {
				// 始终收集所有类型列表项，即使是从
				// 不同类型列表中收集，前提是作者打算包含所有类型。
				types = append(types, f.Type)
				if tlist != nil && tlist != name {
					check.errorf(name, _Todo, "cannot have multiple type lists in an interface")
				}
				tlist = name
				continue
			}

			typ := check.typ(f.Type)
			sig, _ := typ.(*Signature)
			if sig == nil {
				if typ != Typ[Invalid] {
					check.invalidAST(f.Type, "%s is not a method signature", typ)
				}
				continue // 忽略
			}

			// 始终收集类型检查方法类型参数，但如果e未启用。
			// （此处需要此额外检查，因为接口方法签名没有
			// 接收器规范。）
			if sig.tparams != nil {
				var at positioner = f.Type
				if tparams := typeparams.Get(f.Type); tparams != nil {
					at = tparams
				}
				check.errorf(at, _Todo, "methods cannot have type parameters")
			}

			// 如果可用，请使用命名接收器类型（以获得更好的错误消息）
			var recvTyp Type = ityp
			if def != nil {
				recvTyp = def
			}
			sig.recv = NewVar(name.Pos(), check.pkg, "", recvTyp)

			m := NewFunc(name.Pos(), check.pkg, name.Name, sig)
			check.recordDef(name, m)
			ityp.methods = append(ityp.methods, m)
		} else {
			// 我们有一个嵌入式类型。completeInterface将
			// 最终验证我们有一个接口。
			ityp.embeddeds = append(ityp.embeddeds, check.typ(f.Type))
			check.posMap[ityp] = append(check.posMap[ityp], f.Type.Pos())
		}
	}

	// 类型约束
	ityp.types = _NewSum(check.collectTypeConstraints(iface.Pos(), types))

	if len(ityp.methods) == 0 && ityp.types == nil && len(ityp.embeddeds) == 0 {
		// 空接口
		ityp.allMethods = markComplete
		return
	}

	// API稳定性排序
	sortMethods(ityp.methods)
	sortTypes(ityp.embeddeds)

	check.later(func() { check.completeInterface(iface.Pos(), ityp) })
}

func (check *Checker) completeInterface(pos token.Pos, ityp *Interface) {
	if ityp.allMethods != nil {
		return
	}

	// completeInterface可以通过LookupFieldormed方法调用，
	// MissingMethod、idential或IdenticalIgnoreTags外部API 
	// 在这种情况下，检查将为零。在这种情况下，类型检查
	// 必须完成，所有接口都应该完成。
	if check == nil {
		panic("internal error: incomplete interface")
	}

	if trace {
		// 类型通常没有位置信息。
		// 如果我们这样做的话未提供有效的pos，请尝试使用
		// 一个足够接近的pos。
		if !pos.IsValid() && len(ityp.methods) > 0 {
			pos = ityp.methods[0].pos
		}

		check.trace(pos, "complete %s", ityp)
		check.indent++
		defer func() {
			check.indent--
			check.trace(pos, "=> %s (methods = %v, types = %v)", ityp, ityp.allMethods, ityp.allTypes)
		}()
	}

	// 检测到无限扩展的接口（由于循环）
	// 其他位置（Checker.validType），所以这里我们简单地假设只有
	// 有有效的接口。将接口标记为完整，以避免
	// 如果某些
	// 原因的有效类型检查稍后发生，则无限递归。
	ityp.allMethods = markComplete

	// 嵌入式接口的方法收集不变；即，身份
	// 一个接口I的方法I.m的Func对象与
	// 嵌入接口I的接口中的方法m相同。另一方面，
	// 如果一个方法是通过多个重叠的嵌入接口嵌入的，我们
	// 不提供“原始m”的保证已被选择用于嵌入
	// 接口。另请参见第34421期。
	// 
	// 如果我们不想再提供此身份保证，而不是
	// 在嵌入中重新使用原始方法，我们可以克隆该方法的Func 
	// 对象并为其提供位置在相应的嵌入式接口上。然后
	// 我们可以去掉下面的mpos映射，只需使用克隆方法的
	// 位置。

	var seen objset
	var methods []*Func
	mpos := make(map[*Func]token.Pos) // 方法规范或方法嵌入位置，即可获得良好的错误消息
	addMethod := func(pos token.Pos, m *Func, explicit bool) {
		switch other := seen.insert(m); {
		case other == nil:
			methods = append(methods, m)
			mpos[m] = pos
		case explicit:
			check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
			check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // 第二个错误，\t缩进
		default:
			// 我们在一个嵌入（未显式声明）方法中有一个重复的方法名。
			// 计算所有类型后检查方法签名（问题#33656）。
			// 如果我们是go1.14之前的版本（不允许重叠嵌入），请在此处报告
			// 错误（尽管我们可以急切地这样做），因为它是相同的
			// 错误消息。
			check.later(func() {
				if !check.allowVersion(m.pkg, 1, 14) || !check.identical(m.typ, other.Type()) {
					check.errorf(atPos(pos), _DuplicateDecl, "duplicate method %s", m.name)
					check.errorf(atPos(mpos[other.(*Func)]), _DuplicateDecl, "\tother declaration of %s", m.name) // 次要错误，\t缩进
				}
			})
		}
	}

	for _, m := range ityp.methods {
		addMethod(m.pos, m, true)
	}

	// 收集类型
	allTypes := ityp.types

	posList := check.posMap[ityp]
	for i, typ := range ityp.embeddeds {
		pos := posList[i] // 嵌入位置
		utyp := under(typ)
		etyp := asInterface(utyp)
		if etyp == nil {
			if utyp != Typ[Invalid] {
				var format string
				if _, ok := utyp.(*_TypeParam); ok {
					format = "%s is a type parameter, not an interface"
				} else {
					format = "%s is not an interface"
				}
				// TODO:更正错误代码。
				check.errorf(atPos(pos), _InvalidIfaceEmbed, format, typ)
			}
			continue
		}
		check.completeInterface(pos, etyp)
		for _, m := range etyp.allMethods {
			addMethod(pos, m, false) // 使用嵌入位置pos而不是m.pos 
		}
		allTypes = intersect(allTypes, etyp.allTypes)
	}

	if methods != nil {
		sort.Sort(byUniqueMethodName(methods))
		ityp.allMethods = methods
	}
	ityp.allTypes = allTypes
}

// intersect计算类型x和y的交集。
// 注意：输入的nil类型代表顶部类型。顶级
// 类型结果返回为nil。
func intersect(x, y Type) (r Type) {
	defer func() {
		if r == theTop {
			r = nil
		}
	}()

	switch {
	case x == theBottom || y == theBottom:
		return theBottom
	case x == nil || x == theTop:
		return y
	case y == nil || x == theTop:
		return x
	}

	xtypes := unpackType(x)
	ytypes := unpackType(y)
	// 计算列表rtypes，其中仅包括xtypes和ytypes中的
	// 类型。
	// 二次算法，但现在已经足够好了。
	// TODO（gri）修复此
	var rtypes []Type
	for _, x := range xtypes {
		if includes(ytypes, x) {
			rtypes = append(rtypes, x)
		}
	}

	if rtypes == nil {
		return theBottom
	}
	return _NewSum(rtypes)
}

func sortTypes(list []Type) {
	sort.Stable(byUniqueTypeName(list))
}

// byUniqueTypeName命名类型列表可以按其唯一的类型名称排序。
type byUniqueTypeName []Type

func (a byUniqueTypeName) Len() int           { return len(a) }
func (a byUniqueTypeName) Less(i, j int) bool { return sortName(a[i]) < sortName(a[j]) }
func (a byUniqueTypeName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

func sortName(t Type) string {
	if named := asNamed(t); named != nil {
		return named.obj.Id()
	}
	return ""
}

func sortMethods(list []*Func) {
	sort.Sort(byUniqueMethodName(list))
}

func assertSortedMethods(list []*Func) {
	if !debug {
		panic("internal error: assertSortedMethods called outside debug mode")
	}
	if !sort.IsSorted(byUniqueMethodName(list)) {
		panic("internal error: methods not sorted")
	}
}

// byUniqueMethodName方法列表可以按其唯一的方法名称排序。
type byUniqueMethodName []*Func

func (a byUniqueMethodName) Len() int           { return len(a) }
func (a byUniqueMethodName) Less(i, j int) bool { return a[i].Id() < a[j].Id() }
func (a byUniqueMethodName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }

func (check *Checker) tag(t *ast.BasicLit) string {
	if t != nil {
		if t.Kind == token.STRING {
			if val, err := strconv.Unquote(t.Value); err == nil {
				return val
			}
		}
		check.invalidAST(t, "incorrect tag syntax: %q", t.Value)
	}
	return ""
}

func (check *Checker) structType(styp *Struct, e *ast.StructType) {
	list := e.Fields
	if list == nil {
		return
	}

	// 结构字段和标记
	var fields []*Var
	var tags []string

	// 对于双重声明检查
	var fset objset

	// 当前字段类型和标记
	var typ Type
	var tag string
	add := func(ident *ast.Ident, embedded bool, pos token.Pos) {
		if tag != "" && tags == nil {
			tags = make([]string, len(fields))
		}
		if tags != nil {
			tags = append(tags, tag)
		}

		name := ident.Name
		fld := NewField(pos, check.pkg, name, typ, embedded)
		// 规范：“在结构中，非空字段名称必须是唯一的。”
		if name == "_" || check.declareInSet(&fset, pos, fld) {
			fields = append(fields, fld)
			check.recordDef(ident, fld)
		}
	}

	// addInvalid将无效类型的嵌入字段添加到
	// 有错误的字段的结构中；这将使结构字段的数量与源保持同步，只要这些字段是uu或具有不同的名称uuu![3]
	addInvalid := func(ident *ast.Ident, pos token.Pos) {
		typ = Typ[Invalid]
		tag = ""
		add(ident, true, pos)
	}

	for _, f := range list.List {
		typ = check.varType(f.Type)
		tag = check.tag(f.Tag)
		if len(f.Names) > 0 {
			// 命名字段
			for _, name := range f.Names {
				add(name, false, name.Pos())
			}
		} else {
			// 嵌入式字段
			// 规范：“嵌入式类型必须指定为类型名T或
			// 指向非接口类型名*T的指针，并且T本身不能是
			// 指针类型。”
			pos := f.Type.Pos()
			name := embeddedFieldIdent(f.Type)
			if name == nil {
				// TODO（rFindley）：此处使用invalidAST会导致测试失败（所有
				// 错误都应该有代码）。把这个清理干净。
				check.errorf(f.Type, _Todo, "invalid AST: embedded field type %s has no name", f.Type)
				name = ast.NewIdent("_")
				name.NamePos = pos
				addInvalid(name, pos)
				continue
			}
			add(name, true, pos)

			// 因为我们有一个名称，所以typ必须是T或*T的形式，其中T是一个（命名或别名）类型的名称
			// 而T（=deref（typ））必须是T的类型。
			// 我们必须将此检查延迟到最后，因为我们不想实例化
			// （通过（T）下的方式）可能不完整的类型。

			// 用于下面的闭包
			embeddedTyp := typ
			embeddedPos := f.Type

			check.later(func() {
				t, isPtr := deref(embeddedTyp)
				switch t := optype(t).(type) {
				case *Basic:
					if t == Typ[Invalid] {
						// 在
						return
					}
					// 不安全之前报告了错误。指针被视为常规指针
					if t.kind == UnsafePointer {
						check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be unsafe.Pointer")
					}
				case *Pointer:
					check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer")
				case *Interface:
					if isPtr {
						check.errorf(embeddedPos, _InvalidPtrEmbed, "embedded field type cannot be a pointer to an interface")
					}
				}
			})
		}
	}

	styp.fields = fields
	styp.tags = tags
}

func embeddedFieldIdent(e ast.Expr) *ast.Ident {
	switch e := e.(type) {
	case *ast.Ident:
		return e
	case *ast.StarExpr:
		// /*T有效，但是**T不是
		if _, ok := e.X.(*ast.StarExpr); !ok {
			return embeddedFieldIdent(e.X)
		}
	case *ast.SelectorExpr:
		return e.Sel
	case *ast.IndexExpr:
		return embeddedFieldIdent(e.X)
	}
	return nil // 无效的嵌入字段
}

func (check *Checker) collectTypeConstraints(pos token.Pos, types []ast.Expr) []Type {
	list := make([]Type, 0, len(types)) // 假设所有类型都是正确的
	for _, texpr := range types {
		if texpr == nil {
			check.invalidAST(atPos(pos), "missing type constraint")
			continue
		}
		list = append(list, check.varType(texpr))
	}

	// 确保每个类型在类型列表中只存在一次。类型可能是
	// 接口，可能还不完整。可以在
	// 结尾处执行此检查，因为这不是代码正确性的要求。
	// 注意：这是一个二次算法，但类型列表往往较短。
	check.later(func() {
		for i, t := range list {
			if t := asInterface(t); t != nil {
				check.completeInterface(types[i].Pos(), t)
			}
			if includes(list[:i], t) {
				check.softErrorf(types[i], _Todo, "duplicate type %s in type list", t)
			}
		}
	})

	return list
}

// 包括报告类型是否在列表中。
func includes(list []Type, typ Type) bool {
	for _, e := range list {
		if Identical(typ, e) {
			return true
		}
	}
	return false
}
